home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / Mm2_txt / INHALT.TXT < prev    next >
Encoding:
Text File  |  1997-02-07  |  20.5 KB  |  307 lines
  1. 0. Inhalt                                                                         1
  2. _______________________________________________________
  3.  
  4. 1. Einführung
  5.  
  6.     1.1  Über Megamax Modula                                         1 -  1
  7.     1.2  Über dieses Handbuch                                               2
  8.     1.3  Kurze Modula-Bibliographie                                          3
  9.          Niklaus Wirth: Programmieren in Modula-2                          3
  10.          Dal Cin/Lutz/Risse: Programmierung in Modula-2                   3
  11.          Richard Gleaves: Modula-2 für Pascal-Programmierer              4
  12.          Dürholt, Schnur: Atari ST Modula-2 Programmierhandbuch         4
  13.          Dieter & Jürgen Geiß: Softwareentwicklung auf dem Atari ST      5
  14.          Dieter & Jürgen Geiß: Vom Anfänger zum GEM-Profi               5
  15.          Jankowski, Rabich, Reschke: Das Atari-ST Profibuch               5
  16.     1.4  Megamax Modula: das Konzept                                      6
  17.          Implementations- und Definitionsmodule                             6
  18.          "Loadtime Linking"                                                   7
  19.          Benutzung des Linkers                                               8
  20.     1.5  Unser Service                                                       9
  21.          Megamax Modula Exchange - MeMoX                               9
  22.          Mailbox                                                             10
  23.          Soforthilfe bei Fehlern                                              11
  24.          Quelltexte der Bibliothek                                           12
  25.          Assembler für 68020/30 und 68881/2                            12
  26.          Portable Bibliotheken für den Atari ST / TT                       13
  27.          ATD - Abstrakte Datentypen                                       14
  28.          Einbindung von Funktionen der Sprache C                          14
  29.     1.6  Anmerkungen zu den Lizenzvereinbarungen                        15
  30.          Software                                                           15
  31.          Handbuch                                                           15
  32.          Haftungsausschluß                                                  16
  33.  
  34. 2. Bedienung des Megamax Modula-Systems
  35.  
  36.     2.1  Los geht's - Installieren und Ausprobieren                     2 -  1
  37.          Voraussetzungen                                                    1
  38.          Die Modula-Disketten                                                2
  39.          Installation ohne Festplatte                                          4
  40.          Installation mit Festplatte                                            5
  41.          Speicherplatzmangel?                                                6
  42.          Mehr Geschwindigkeit...                                              7
  43.          Namenskonventionen                                                 8
  44.          Mathe-Koprozessor (FPU, SFP004, Atari TT                       8
  45.          Ein erstes Programm                                                9
  46.     2.2 Shell                                                            2 - 15
  47.          Aufruf der Shell                                                    15
  48.          Das Shell-Desktop                                                 15
  49.          Ausführen von Programmen und anderen Dateien                  18
  50.          Ausführen speziell von Code-Dateien (Programme, Module)        19
  51.          Programmaufruf und -abbruch bei gelinkten Programmen          22
  52. 0. Inhalt                                                                         2
  53. _______________________________________________________
  54.  
  55.  
  56.          Das Binden der Module                                             22
  57.          Resident-Laden von Code-Dateien (Programme, Module)           25
  58.          Laden gelinkter Programme                                        26
  59.          Menüzeile der Shell                                                28
  60.          Shell-Parameter                                                    29
  61.          Umgebungsinformationen                                           30
  62.          Tasten-Funktionen                                                  31
  63.          Batch-Dateien                                                      32
  64.          Suchpfade und Pfadlisten                                           36
  65.          Umgang mit mehreren Projekten                                   39
  66.          Fehlermeldungen der Shell                                          41
  67.     2.3 Editor                                                          2 - 43
  68.          Einführung                                                          43
  69.          Wahl des Editors                                                   43
  70.          Vorbereitungen und Parameter                                     45
  71.          Aufruf des Editors                                                 46
  72.     2.4 Compiler                                                       2 - 47
  73.          Aufruf des Compilers                                              47
  74.          Die erzeugten Dateien                                              48
  75.          Übersetzungsfehler                                                 48
  76.          Parameter                                                          49
  77.          Definitions-Codes: Bibliothek und Komprimierung                   50
  78.          Dekomprimieren der Dateien in der Library                        51
  79.          Protokoll                                                            51
  80.     2.5 Debugger                                                       2 - 53
  81.          Übersetzen im Debug-Modus                                       53
  82.          Ausführen im Debug-Modus                                        54
  83.          Scanner - Suchen der Fehlerposition                              55
  84.          Manuelles Scannen                                                 56
  85.     2.6 Linker                                                          2 - 59
  86.          Funktion                                                            59
  87.          Bedienung                                                          59
  88.          Fehlermeldungen                                                    60
  89.          Parameter                                                          61
  90.          Treiber- bzw. Konfigurationsmodule                                61
  91.          Komprimierung (Optimierung) des erzeugten Programms          63
  92.          Stack-Größe                                                       65
  93.          Binden von Accessory-Programmen                                65
  94.          Arbeitsweise des Linkers                                           65
  95.     2.7 Make und ModRef                                              2 - 69
  96.          Prinzip eines Make                                                 69
  97.          Arbeitsweise von Make                                             69
  98.          Erzeugung einer Make-Datei (ModRef)                             71
  99.          Anwendung von Make                                              72
  100.          Alle Module übersetzen (Build)                                     73
  101.          Fehlermeldungen des Make                                         73
  102.          Syntax der Make-Datei                                             74
  103. 0. Inhalt                                                                         3
  104. _______________________________________________________
  105.  
  106.  
  107. 3. Programmieren in Megamax Modula-2
  108.  
  109.     3.1  Sprachumfang                                                  3 -  1
  110.          Wirthscher Standard (PIM-Standard)                               1
  111.          ISO-Standard                                                        2
  112.          Standard gegen Erweiterungen                                      3
  113.          Die Megamax-Implementation: Einschränkungen und Erweiterungen 4
  114.          Standardprozeduren                                                 5
  115.          Standardtypen: Größe und Wertebereich                            8
  116.          Standardkonstanten                                                  8
  117.          Typen CARDINAL und INTEGER                                      8
  118.          Typen SHORTCARD und SHORTINT                                 9
  119.          Typen LONGCARD und LONGINT                                    9
  120.          Typen REAL und LONGREAL                                        10
  121.          Funktionen SHORT und LONG                                      11
  122.          Kompatibilität von ADDRESS, POINTER, LONGCARD, Opaque      11
  123.          Angabe von Speichergrößen                                        11
  124.          Funktionen MIN und MAX                                           12
  125.          Exportlisten in Definitionsmodulen                                  12
  126.          Syntax eines Variant-Records                                      12
  127.          Unterbereichs-Deklaration                                          13
  128.          FORWARD-Deklaration                                             13
  129.          Externe Variable                                                   13
  130.          Funktions-Prozeduren                                              14
  131.          Lokale Prozeduren als aktuelle Parameter                         15
  132.          Zuweisungen von LONGCARD/-INT auf SHORTCARD/-INT        16
  133.          Bedingungen für Laufvariable von FOR-Schleifen                   16
  134.          SET-Konstrukturen                                                 17
  135.          Mehrdimensionale offene Felder                                    18
  136.          Größe von INTEGER und CARDINAL                                18
  137.          Datengröße bei Open Arrays                                       18
  138.          Aggregate (value constructor)                                      19
  139.          Verkettung von String-Konstanten                                 20
  140.          Funktion LENGTH                                                   21
  141.          Funktionen FLOAT und LFLOAT                                    21
  142.          Funktion INT                                                        21
  143.          Kompatibilität bei Open Arrays                                     22
  144.          Kompatibilität bei String-Zuweisungen                              22
  145.          REF- (CONST-) Parameter                                        22
  146.     3.2 Interne Datenformate                                          3 - 25
  147.          Ablage von Strukturen im Speicher                                25
  148.          SETs und BITSET                                                  25
  149.          LONG-Werte                                                       25
  150.          Packen von BYTE-Daten                                            26
  151.     3.3 Das SYSTEM-Modul                                           3 - 27
  152.          Typ ADDRESS                                                      28
  153.          Typen LONGWORD, WORD, BYTE und LOC                        28
  154. 0. Inhalt                                                                         4
  155. _______________________________________________________
  156.  
  157.  
  158.          Funktionen ADR und TSIZE                                         29
  159.          Konstante CompilerVersion und CompilerSubVersion               29
  160.          Type BITNUM und Funktionen SHIFT und ROTATE                 29
  161.          Funktion CAST                                                     30
  162.          Funktion CADR                                                     31
  163.          Prozeduren CODE, LOAD und STORE                              31
  164.          Prozeduren CALLSYS und CALLEXT                               32
  165.          Prozeduren NEWPROCESS, TRANSFER und LISTEN               33
  166.          Prozedur IOTRANSFER                                             34
  167.          Prozedur IOCALL                                                   34
  168.     3.4 Compilerdirektiven                                              3 - 36
  169.          Syntax einer Direktive in der Compiler-Parameter-Box            36
  170.          Syntax einer Direktive im Programmtext                           37
  171.          Groß-/Kleinschreibung (Case Sensitivity)                           37
  172.          Bereichsprüfungen (Range Checking)                               38
  173.          Stackplatz-Prüfung (S)                                             38
  174.          Testhilfen (Debugging, E)                                           39
  175.          Lokale Prozeduren als aktuelle Parameter (H)                     40
  176.          Erweiterte Syntax (A)                                              40
  177.          Zuweisung LONGCARD/-INT auf SHORTCARD/-INT (K)           40
  178.          Automatische Register-Optimierung bei FOR-Schleifen (J)         40
  179.          Optimierte Rückgabe von Funktionsergebnissen im Register (Z)   41
  180.          SET-Format (U)                                                    41
  181.          Register-Variable (Reg)                                            42
  182.          Mathe-Koprozessor (FPU)                                          43
  183.          Ausgaben des Compilers (Quiet Compilation)                       44
  184.          Zugriff auf lokale Variable (Linking)                                45
  185.          Wahl der Namensendung (Extension)                               45
  186.          Einschieben externer Textfiles (Include File)                       46
  187.          Bibliotheksvorgabe (Use Library)                                   47
  188.          Protokoll mit Statistik(V, P)                                       47
  189.          Bedingte Compilierung (?)                                          47
  190.          System-Module mit "shared data" (Y)                             48
  191.          Entfernen nicht benötigter Module beim optimierten Linken (B)    49
  192.          Compiler-Warnungen (W)                                          49
  193.          Übersicht: Compilerdirektiven                                       50
  194.  
  195. 4. Der 68000 Assembler
  196.  
  197.     4.1  Grundlagen und Syntax                                         4 -  1
  198.          Assembler-Anweisungen in Modula-Programmen                    1
  199.          Aufbau von Assembleranweisungen                                  2
  200.          Befehlscodes und Adressierungsarten                               2
  201.          Label (Marken)                                                      3
  202.          Relative Sprünge (Bcc & BSR)                                       4
  203.     4.2 Einfache Assembler-Anwendungen                                   5
  204.          Belegung der CPU-Register                                          5
  205. 0. Inhalt                                                                         5
  206. _______________________________________________________
  207.  
  208.  
  209.          Zugriff auf globale Variable                                          5
  210.          Zugriff auf lokale Variable                                           7
  211.     4.3 Assembler für Experten                                        4 -  8
  212.          Pseudo-Opcodes                                                     8
  213.          Belegung der CPU-Register                                          9
  214.          Zugriff auf Modula-Konstanten                                     10
  215.          Zugriff auf globale Variable. speziell ARRAYs                      11
  216.          Zugriff auf lokale Variable                                         11
  217.          Fehlerprüfungen vom Assembler                                    13
  218.          Aufruf globaler Prozeduren, Parameterübergabe                   13
  219.          Aufruf lokaler Prozeduren                                          15
  220.          Übernahme von Parametern                                        16
  221.  
  222. 5. Modulbibliothek
  223.  
  224.     5.1  Allgemeines zur Bibliothek                                     5 -  1
  225.          Funktionsübersicht                                                   1
  226.          Vorhandene Module                                                  2
  227.          Allgemeiner Hinweis - Sys-Funktionen                               6
  228.          Übernahme (Portierung) fremder Modula-2 Programme             7
  229.              Strings                                                          7
  230.              Ein-/Ausgabe                                                    8
  231.          Hinweise zu den Quelltexten...                                     10
  232.            ...MM2Shell                                                      10
  233.            ...GEMError & SimpleError                                      11
  234.            ...MOSConfig                                                     11
  235.          Bedienung der Eingabefunktionen                                   11
  236.          Eingabeformate bei Convert & StrConv                            12
  237.          Hinweise zu GEMDOSIO und TOSIO                               12
  238.          Hinweise zu ALLOCATE                                            12
  239.          Hinweise zu AES-/VDI-Funktionen (FormAlert, ...Mouse)          13
  240.          Der richtige Gebrauch der UpdateWindow-Funktion...              13
  241.            ...bei der Accessory-Initialisierung                               13
  242.            ...bei Timer-Events mit GEMDOS-Aufrufen                      13
  243.          Hinweise zur Benutzung der FPU in Accessories                   14
  244.     5.2 Programme, Module und Prozesse                             5 - 15
  245.          Das Modulkonzept                                                  15
  246.          Vom Modul zum gelinkten Programm                               16
  247.          Prozesse                                                           18
  248.          Prozeßkontrolle                                                     22
  249.          Prozeßinformationen                                                23
  250.     5.3 Laufzeitfehler-Behandlung                                      5 - 25
  251.          Was sind Laufzeitfehler?                                          25
  252.          Fehlergruppen                                                      26
  253.          Allgemeine Laufzeitfehler                                           27
  254.          Dateifehler                                                         30
  255. 0. Inhalt                                                                         6
  256. _______________________________________________________
  257.  
  258.  
  259.          Fehlerbehandlung mit dem Modul EasyExceptions                   31
  260.          Accessories                                                        32
  261.     5.4 Dateisystem                                                    5 - 33
  262.          Dateimodi (Binär/Text)                                             33
  263.          Öffnen einer Datei                                                 34
  264.          Ein-/Ausgabe von Daten                                           35
  265.          Dateiende-Behandlung                                              36
  266.          Diverse Dateifunktionen (Modul 'Files')                             40
  267.          Fehlerbehandlung im Dateisystem                                   41
  268.          Unterschiede zwischen Binär- und Textmodus                     42
  269.          Modul 'InOut'                                                       43
  270.          Konfiguration eigener Unittreiber                                   44
  271.     5.5 Grafikdarstellung im Atari ST                                  5 - 45
  272.          Einführung                                                          45
  273.     5.6 Line A - Routinen                                                  47
  274.          Der Fontheader                                                     47
  275.          Die Line A - Variablen                                             49
  276.          Der Deskriptor für BitBlockTransfer                                52
  277.     5.7 GEM                                                                54
  278.          VDI                                                                 54
  279.          AES                                                                55
  280.          Mega-GEM                                                         67
  281.          Ganz unten...                                                       68
  282.  
  283. Anhang
  284.  
  285.     A.1  Fehlermeldungen des Compilers
  286.     A.2 Fehlermeldungen zur Laufzeit und des Loaders
  287.     A.3 Interne Datenformate
  288.     A.4 Registerbelegung zur Laufzeit
  289.     A.5 Übersicht Compileroptionen
  290.     A.6 Backus-Naur-Notation
  291.     A.7 Modula-Syntaxdiagramme
  292.     A.8 Modula-Syntax in Backus-Naur-Notation
  293.     A.9 Aufbau der Codemodule
  294.     A.10Begriffserläuterungen
  295.     A.11 Anpassen alter Megamax-Programme (Systemversion 1)
  296.  
  297.     B.   Texte der Definitionsmodule
  298.  
  299.     C.1  Dokumentation zum Editor GEP ED
  300.                                          _
  301.     C.2 Dokumentation zum Editor GME
  302.     C.3 Dokumentation zum Resource Construction Program
  303.  
  304.     D.  Übersicht aller Bezeichner der Bibliothek
  305.  
  306.     E.   Index
  307.